(function (global, undefined) {
    if (global.dlCommon) {
        return
    }
    var dlCommon = global.dlCommon = {
        // The current version of js being used
        version: "0.1"
    }
    var __loadingCount = 0;
    var __loadingindex = 0;

    dlCommon.ajaxPost = function (url, postdata, callback, isshowloading) {
        if (isshowloading && __loadingCount == 0) {
            //--加载框处理
            __loadingindex = dlCommon.Loading();
        }
        if (isshowloading)
            __loadingCount++;

        $.ajax({
            url: url,
            type: 'post',
            data: postdata,
            dataType: 'json',
            xhrFields: {
                withCredentials: true
            },
            crossDomain: true,
            success: function (data) {

                if (isshowloading)
                    __loadingCount--;
                if (isshowloading && __loadingCount == 0) {
                    layer.close(__loadingindex);
                }
                callback && callback(data);
            }
        });
    }
//===================================ajax
    dlCommon.getJSON = function (url, data, callback, isshowloading) {

        if (isshowloading && __loadingCount == 0) {
            //--加载框处理
            __loadingindex = dlCommon.Loading();
        }
        if (isshowloading)
            __loadingCount++;
        $.getJSON(url, data, function (obj) {
            if (isshowloading)
                __loadingCount--;
            if (isshowloading && __loadingCount == 0) {
                layer.close(__loadingindex);
            }
            callback && callback(obj);
        })
    }
    dlCommon.post = function (url, data, callback, isshowloading) {
        var index;
        if (isshowloading) {
            //--加载框处理
            index = dlCommon.Loading();
        }
        $.post(url, data, function (obj) {
            if (isshowloading)
                layer.close(index);
            callback && callback(obj);
        })
    }
    dlCommon.ajax = function (url, data, callback, isshowloading) {
        var index;
        if (isshowloading) {
            //--加载框处理
            index = dlCommon.Loading();
        }
        $.ajax({
            url: url,
            data: data,
            type: 'post',
            dataType: 'json',
            contentType: 'application/json; charset=utf8',
            success: function (data) {
                if (data == null) {
                    return;
                }
                if (isshowloading)
                    layer.close(index);
                callback && callback(obj);
            },
            error: function (xhr) {
                if (isshowloading)
                    layer.close(index);
                alert("出错了!" + xhr.Message);
            },
            complete: function (XHR, TS) {
                XHR = null
            }
        });
    }

    dlCommon.ajaxJsonStr = function (url, data, callback, isshowloading) {
        var index;
        if (isshowloading) {
            //--加载框处理
            index = dlCommon.Loading();
        }
        $.ajax({
            url: url,
            data: JSON.stringify(data),
            type: 'post',
            contentType: "application/json; charset=utf-8",
            dataType: 'json',
            success: function (obj) {
                if (isshowloading)
                    layer.close(index);
                callback && callback(obj);
            },
            error: function (xhr) {
                if (isshowloading)
                    layer.close(index);
                alert("出错了!" + xhr.Message);
            },
            complete: function (XHR, TS) {
                XHR = null
            }
        });
    }
  
    //=======================Layui集成
    dlCommon.layeropen = function (w, h, title, url, newoption) {
        //iframe窗
        var options = {
            type: 2,
            title: title,
            closeBtn: 1, //不显示关闭按钮
            shade: [0.3, '#000000'],
            area: [w + 'px', h + 'px'],
            offset: 'auto', //右下角弹出
            shift: 0,
            content: url //iframe的url，no代表不显示滚动条
        }
        if (newoption) {
            options = dlCommon.extend(true, options, newoption)
        }
        var index = layer.open(options);
        return index;
    }
    dlCommon.layerOpenDiv = function (w, h, title, divobj, newoption) {
        var area = [w + 'px', h + 'px'];
        if (!h) {
            area = w + 'px';
        }
        var options = {
            type: 1,
            title: title,
            area: area,
            shade: [0.3, '#000000'],
            content: divobj
        }
        if (newoption) {
            options = dlCommon.extend(true, options, newoption)
        }
        var index = layer.open(options);
        return index;
    }
    //layer弹窗方法包含 alert、confirm
    dlCommon.layerSuccess = function (msg, callback) {
        return layer.alert(msg, {icon: 1}, function (index) {
            callback && callback();
            layer.close(index);
        });
    }
    dlCommon.layerError = function (msg, callback) {
        return layer.alert(msg, {icon: 11}, function (index) {
            callback && callback();
            layer.close(index);
        });
    }
    dlCommon.layerInfo = function (msg, callback) {
        return layer.alert(msg, {icon: 0}, function (index) {
            callback && callback();
            layer.close(index);
        });
    }
    dlCommon.layerConfirm = function (msg, success, cancel) {
        return layer.confirm(msg, {icon: 4, title: '提示'}, function (index) {
            success && success();
            layer.close(index);
        }, cancel);
    }
    dlCommon.layerMsg = function (msg, time) {
        time = time || 2000;
        return layer.msg(msg, {time: time});
    }
    dlCommon.Loading = function (newoption) {
        var options = {shade: [0.4, '#eee']};
        if (newoption) {
            options = dlCommon.extend(true, options, newoption)
        }
        return layer.load(2, options);
    }
    dlCommon.layerTableOn=function(id,callback){
        layui.table.on('row('+id+')', function(obj){
            $(obj.tr).addClass('my_table_click')
                .siblings().removeClass('my_table_click');
            callback&&callback(obj);
        });
    }
    dlCommon.layerSelectTable=function(id){
        $("[lay-id='"+id+"'] .layui-table tr[data-index=0]").click();
    }
    dlCommon.closeParentLayer=function(index){
        if(index!=undefined&&index!=null)
        {
            parent.layui&&parent.layui.layer&&parent.layui.layer.close(index);
            parent.layer&&parent.layer.close(index);
        }
        else{
            parent.layui&&parent.layui.layer&& parent.layui.layer.closeAll(); //关闭所有的iframe层
            parent.layer&& parent.layer.closeAll(); //关闭所有的iframe层
        }

    }

    //页面高度
    dlCommon.getWinWidth=function() //函数：获取尺寸
    {
        var winwidth = 0;
        //获取窗口宽度
        if (window.innerWidth)
            winwidth = window.innerWidth;
        else if ((document.body) && (document.body.clientWidth))
            winwidth = document.body.clientWidth;

        //通过深入Document内部对body进行检测，获取窗口大小
        if (document.documentElement && document.documentElement.clientHeight && document.documentElement.clientWidth) {
            winwidth = document.documentElement.clientWidth;
        }
        return winwidth;
    }
    //页面宽度
    dlCommon.getWinHeight=function(){
        //获取窗口宽度
        var winheight = 0;

        //获取窗口高度
        if (window.innerHeight)
            winheight = window.innerHeight;
        else if ((document.body) && (document.body.clientHeight))
            winheight = document.body.clientHeight;
        //通过深入Document内部对body进行检测，获取窗口大小
        if (document.documentElement && document.documentElement.clientHeight && document.documentElement.clientWidth) {
            winheight = document.documentElement.clientHeight;
        }
        return winheight;
    }

    //获取地址栏参数
    dlCommon.getUrlParam=function(name,type){
        var reg = new RegExp("(^|\\?|&)" + name + "=([^&]*)(\\s|&|$)", "i");
        if(reg.test(location.href)&&type=="decode"){
            return decodeURI(RegExp.$2.replace(/\+/g, " "));
        }
        if (reg.test(location.href)) return unescape(RegExp.$2.replace(/\+/g, " "));
        return "";
    }
    dlCommon.initDropButton=function(){
        $(".dl-btn-group").on("click",function (e) {
            $(this)[0].classList.toggle("dl-open");
        })
        $("body").on("click",function (e) {
            if(!$(e.target).parents().hasClass("dl-btn-group")){
                $(".dl-btn-group").removeClass("dl-open");
            }
        })
    }

//-----------------深拷贝方法
    var class2type = {};
    ['Boolean', 'Number', 'String', 'Function', 'Array', 'Date', 'RegExp', 'Object', 'Error'].forEach(function (name) {
        class2type["[object " + name + "]"] = name.toLowerCase();
    })
    dlCommon.type = function (obj) {
        return obj == null ? String(obj) : class2type[{}.toString.call(obj)] || "object";
    };
    /**
     *  isArray
     */
    dlCommon.isArray = Array.isArray ||
        function (object) {
            return object instanceof Array;
        };
    /**
     *  isArrayLike
     * @param {Object} obj
     */
    dlCommon.isArrayLike = function (obj) {
        var length = !!obj && "length" in obj && obj.length;
        var type = dlCommon.type(obj);
        if (type === "function" || dlCommon.isWindow(obj)) {
            return false;
        }
        return type === "array" || length === 0 ||
            typeof length === "number" && length > 0 && (length - 1) in obj;
    };
    /**
     *  isWindow(需考虑obj为undefined的情况)
     */
    dlCommon.isWindow = function (obj) {
        return obj != null && obj === obj.window;
    };
    /**
     *  isObject
     */
    dlCommon.isObject = function (obj) {
        return dlCommon.type(obj) === "object";
    };
    /**
     *  isPlainObject
     */
    dlCommon.isPlainObject = function (obj) {
        return dlCommon.isObject(obj) && !dlCommon.isWindow(obj) && Object.getPrototypeOf(obj) === Object.prototype;
    };
    /**
     *  isEmptyObject
     * @param {Object} o
     */
    dlCommon.isEmptyObject = function (o) {
        for (var p in o) {
            if (p !== undefined) {
                return false;
            }
        }
        return true;
    };
    /**
     *  isFunction
     */
    dlCommon.isFunction = function (value) {
        return dlCommon.type(value) === "function";
    };
    dlCommon.extend = function () {
        var options, name, src, copy, copyIsArray, clone,
            target = arguments[0] || {},
            i = 1,
            length = arguments.length,
            deep = false;
        /*
         变量 options：指向某个源对象。
         变量 name：表示某个源对象的某个属性名。
         变量 src：表示目标对象的某个属性的原始值。
         变量 copy：表示某个源对象的某个属性的值。
         变量 copyIsArray：指示变量 copy 是否是数组。
         变量 clone：表示深度复制时原始值的修正值。
         变量 target：指向目标对象,申明时先临时用第一个参数值。
         变量 i：表示源对象的起始下标，申明时先临时用第二个参数值。
         变量 length：表示参数的个数，用于修正变量 target。
         变量 deep：指示是否执行深度复制，默认为 false。

         ps:源对象指的是把自己的值付给别人的对象；目标对象指的是被源对象赋值的对象
         */
        // 如果第一个参数传入的是布尔值
        if (typeof target === "boolean") {
            deep = target;//设置deep变量，确定是深拷贝还是浅拷贝
            target = arguments[1] || {};//将目标对象设为第二个参数值。
            i = 2;//源对象的起始下标设为2（即从第三个参数开始算源对象）
        }
        // Handle case when target is a string or something (possible in deep copy)
        //嗯，原英文解释的很清楚
        if (typeof target !== "object" && !dlCommon.isFunction(target)) {
            target = {};
        }
        // 如果没有目标对象，那么目标对象就是jquery对象
        if (length === i) {
            target = this;
            --i;
        }
        //拷贝的核心部分代码
        for (; i < length; i++) {//遍历源对象
            // Only deal with non-null/undefined values
            if ((options = arguments[i]) != null) {//options就是源对象
                // Extend the base object
                for (name in options) {//遍历源对象的属性名
                    src = target[name];//获取目标对象上，属性名对应的属性
                    copy = options[name];//获取源对象上，属性名对应的属性
                    // 如果复制值copy 与目标对象target相等，
                    //为了避免深度遍历时死循环，因此不会覆盖目标对象的同名属性。
                    if (target === copy) {
                        continue;
                    }
                    //递归地将源对象上的属性值合并到目标对象上
                    //如果是深拷贝，且待拷贝的对象存在，且是普通对象或是数组
                    //这一个判断条件非常关键，这正是之前疑问的症结
                    //首先，普通对象的定义是:通过 "{}" 或者 "new Object" 创建的
                    //回到之前的疑问，目标对象tobeCloned的属性o对象的obj不是普通对象，也不是数组，所以程序不会走到下面的分支
                    if (deep && copy && ( dlCommon.isPlainObject(copy) || (copyIsArray = dlCommon.isArray(copy)) )) {
                        if (copyIsArray) {
                            //如果是数组
                            copyIsArray = false;
                            clone = src && dlCommon.isArray(src) ? src : [];
                            
                        } else {
                            clone = src && dlCommon.isPlainObject(src) ? src : {};
                        }
                        // 递归地拷贝
                        target[name] = dlCommon.extend(deep, clone, copy);
                    } else if (copy !== undefined) {
                        //会走到这个分支，这个分支的处理很暴力，就是把源对象的属性，直接赋给源对象。
                        //对于上文中tobeCloned对象的属性o，没有进一步递归地拷贝，而是直接把引用赋给源对象
                        //所以改变tobeCloned的o属性时，目标对象的o属性也被改变了。
                        target[name] = copy;
                    }
                }
            }
        }
        // Return the modified object
        return target;
    };
    //批量删除数据
    dlCommon.DeleteBetch = function (oldarr, delarr) {
        //临时数组存放
        var tempArray1 = [];//临时数组1
        var tempArray2 = [];//临时数组2
        for (var i = 0; i < delarr.length; i++) {
            tempArray1[delarr[i]] = true;//将数array2 中的元素值作为tempArray1 中的键，值为true；
        }
        
        for (var i = 0; i < oldarr.length; i++) {
            if (!tempArray1[oldarr[i]]) {
                tempArray2.push(oldarr[i]);//过滤array1 中与array2 相同的元素；
            }
        }
        // console.log(tempArray2)
        return tempArray2;
    }
    
    //限制访问的频率，主要用于搜索等业务
    dlCommon.debounce = function (func, wait, immediate) {
        // immediate默认为false
        var timeout, args, context, timestamp, result;
        
        var later = function () {
            // 当wait指定的时间间隔期间多次调用_.debounce返回的函数，则会不断更新timestamp的值，导致last < wait && last >= 0一直为true，从而不断启动新的计时器延时执行func
            var last = Date.now() - timestamp;
            
            if (last < wait && last >= 0) {
                timeout = setTimeout(later, wait - last);
            } else {
                timeout = null;
                if (!immediate) {
                    result = func.apply(context, args);
                    if (!timeout) context = args = null;
                }
            }
        };
        return function () {
            context = this;
            args = arguments;
            timestamp = Date.now();
            // 第一次调用该方法时，且immediate为true，则调用func函数
            var callNow = immediate && !timeout;
            // 在wait指定的时间间隔内首次调用该方法，则启动计时器定时调用func函数
            if (!timeout) timeout = setTimeout(later, wait);
            if (callNow) {
                result = func.apply(context, args);
                context = args = null;
            }
            
            return result;
        };
    };
    
    Date.prototype.Format = function (fmt) {
        var o = {
            "M+": this.getMonth() + 1,                      //月份
            "d+": this.getDate(),                           //日
            "H+": this.getHours(),                          //小时
            "m+": this.getMinutes(),                        //分
            "s+": this.getSeconds(),                        //秒
            "q+": Math.floor((this.getMonth() + 3) / 3),    //季度
            "S": this.getMilliseconds()                     //毫秒
        };
        if (/(y+)/.test(fmt))
            fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
        for (var k in o)
            if (new RegExp("(" + k + ")").test(fmt))
                fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
        return fmt;
    };
})(this)